feat(ui,api): edit model predictions and save versioned results - #136

Preparing an embedding model for editing failed, and would have wasted
a multi-gigabyte container job even once it worked.

Reuse the tiles we already have. The embedding workflow tiles the same
footprints from the same PMTiles archive, keyed on the same integer
row-index id, and records it as Model.pmtilesUrl. needs_preparation only
looked at ImageLayer.footprintPmtilesUrl, so it rebuilt a byte-for-byte
equivalent archive. Preparation now resolves the model's own archive
first, and GetModelArtifact serves footprint_pmtiles from it, which also
means that kind no longer needs an imageLayerId for embedding models.

Stop importing the queue SDK inside the training image. The workflow
stored its outputs through ArtifactProcessor, which also drives zip jobs
and therefore imports azure.storage.queue — a package the training image
does not install, so the job died with ModuleNotFoundError after all the
real work was done. It now talks to UnifiedArtifactStorage directly,
constructed exactly as ArtifactProcessor does; putting bytes in blob
storage is all this workflow ever needed.

Verified against a real embedding model in the local stack: preparation
reports tilesReady immediately, the job reaches Processed, and the
sidecar serves 1496 buildings with every column the same length.

Build the layer's footprint PMTiles as part of image-layer creation, so
a trained-inference model opens straight into the editor instead of
waiting on a tiling job. Tippecanoe lives only in the training image —
not in imageryprep and not in the Functions app — so the tiling itself
stays a queued job; imagery prep simply enqueues it once the footprints
are cached.

That needed a layer-only mode for the prep job. modelId and the
predictions URL are now optional: without them the job builds the
PMTiles, skips the sidecar, and records status on the image layer rather
than the model. The message schema is unchanged, so the queue contract
stays backward compatible, and the on-demand path still tiles older
layers when someone opens the editor. Layer-time status writes patch
only the tiling fields, because imagery prep is writing the same
document around the same time. Enqueue failures are logged and
swallowed: tiles are an optimisation, and the editor can still build
them on demand.

Add a swipe comparison to the editor: pre-event against post-event, or
basemap against post-event when the layer has no pre-event imagery.
atlas.SwipeMap reveals the PRIMARY map on the left and clips the
SECONDARY, so the comparison map is primary and the editor map is
secondary — moving the divider left uncovers more of the editing map.
A recent PR shipped that description inverted, so a test pins the
wording. Editing is wired to both panes and feature-state and paint
expressions are mirrored across renderers; otherwise half the map is
inert and the far side draws every footprint unlabeled. A/S/D move the
divider, consistent with the other map views.

Verified in the local stack: a layer-only job runs tippecanoe for real
and lands footprintPmtilesUrl, and the tiles serve as valid PMTiles.

Review asked for prediction editing to be a mode inside the existing
View Results page rather than a screen of its own. Doing that surfaced
why the two workflows had never really shared a results story.

The viewer was raster-only: a pre-coloured visualizer COG plus a raw
predictions raster, both produced solely by the train/infer workflow.
The embedding workflow makes no rasters at all, so pointing it at the
viewer would have shown an empty map — and no code path anywhere
rendered per-building predictions, for either workflow. So the viewer
now draws predicted building footprints as vectors from the footprint
tiles and the attribute sidecar, artifacts both workflows already
produce, and the rasters become optional layers that simply do not
appear when a model has none. That is what lets both workflows produce
mostly the same results and be handled the same way.

Editing rides on that same layer. A pencil beside Back, or E, turns the
footprints interactive: click to set a class, ctrl+drag to box-select,
right-click to clear an override back to the derived class, with the
threshold slider shown only where re-thresholding means anything — the
embedding workflow's damage fraction is a degenerate 0/1 copy. Leaving
edit mode restores the read-only view and confirms before discarding
unsaved work. The standalone screen, its route and both model-row Edit
buttons are gone, and with them the logic that existed only to disable
those buttons.

The embedding row gains the View Results it never had.

Three places disagreed about whether a model has results, so there is
now one rule in hastegeo, surfaced as predictionsReady, and publishing
uses it too rather than keeping a fourth copy. Reads resolve their
source through resolve_prediction_source, so an analyst's edits finally
reach the reports instead of being written and then ignored; the newest
version wins and an explicit version can be requested, with no mutable
"active version" pointer, which ADR-0005 deliberately avoided.

Guards the null rasters this makes possible: four raster loaders
dereferenced fields that are now absent for embedding models, and one
older payload shape handed them a tile template with an empty url that
would have quietly served 404s rather than failing.

Saving an edit produced a version nobody could reach. The history was
rendered only inside the edit panel, so a read-only viewer could not see
that versions existed, nothing ever refetched to draw a different one,
and every download button fetched the raw output regardless.

Switching was not simply unwired. The attribute sidecar the viewer draws
from is keyed per model, not per version, so it always described the raw
predictions; saving wrote a GeoPackage but no sidecar. There was nothing
version-specific to render. Every saved version now gets its own sidecar,
written in the same call as its GeoPackage so the two cannot drift, which
makes drawing a version the same code path as drawing the raw output with
a different URL. The builder moves out of the training workflow into a
shared module so the API can produce one without importing an image it
has no business importing.

Versions saved before this are backfilled by the tiles job, idempotently
and skipping any that already have a sidecar. A version still waiting is
offered as disabled with the reason, and the raw sidecar is deliberately
never substituted for a missing one — quietly drawing the wrong classes
is worse than drawing nothing.

The selector sits in the read-only view, and switching rebuilds the
source, layers and feature-state on both swipe panes. Feature-state is
per-renderer and the source id is reused, so state is cleared before the
source is removed; otherwise one pane keeps the previous version's
colours, which is how this repo has twice shipped a half-updated map.

Selection moves the map only — the reports keep reading the newest
version — so the screen says when the two diverge rather than leaving it
to be discovered.

Downloads go through the artifact route, which already handles auth and
ranges, instead of rewriting storage URLs.

Also fixes a data-loss hazard the switching exposed: saves always derive
from the raw GeoPackage, so saving on top of a loaded version had to
resend that version's classes or it would silently discard the edits it
was built on.

…k zoom

Editing a footprint's class went through two controls that overlapped: a
"Clicking a footprint" radio group whose default was a cycle mode, and a
separate row of buttons that set the *selected* building's class. The two
were coupled — pressing 1/2/3, or using the buttons, silently changed the
click mode as a side effect — so what a click would do depended on state
the analyst had changed several actions ago.

Replace both with one class picker. The picked class is what every edit
gesture applies: left-click a footprint, or Ctrl+drag to box-select many.
Right-click still undoes an edit. The cycle mode is gone, along with
cycleClass() and the branch that advanced each building from its own class
during a box-select.

Picking a class no longer edits anything on its own. Relabelling whatever
happened to be selected, because the analyst pressed a number key to line
up their next click, is the surprise this mode should not have; Enter is
now the explicit "apply to the selected building" for the arrow-key review
flow, and is listed in the shortcut help.

normalizeEditClass() guards the one-way door: every path that writes an
override now funnels through it, so a stale value (the old "cycle"
sentinel, say) cannot reach the overrides map and, from there, a saved
GeoPackage.

Also disable Azure Maps' double-click zoom for as long as edit mode is on.
Labelling two neighbouring buildings quickly registers as a double-click,
and the map zoomed out from under the analyst mid-edit. Panning and scroll
zoom are untouched, and the gesture is restored on exit and on unmount.

Footprint geometry belongs to the image layer: every model trained on a
layer draws the same buildings. Two jobs were tiling it anyway. Imagery
prep builds the layer archive when the footprints are cached, and the
embedding job built its own per-model copy on top of that.

The two archives were the same file. Both ran tippecanoe with the same
layer name, the same --use-attribute-for-id=id, the same -y id -y
overture_id, and the same zoom range, over the same rows in the same
order (embed_buildings reads the layer footprints, reset_index, and keeps
every row including the ones with no valid tokens). So an embedding layer
paid for a byte-for-byte duplicate.

The embedding workflow no longer tiles. tippecanoe and subprocess drop
out of it entirely, and it emits the embeddings GeoJSON, the HFTR feature
sidecar and the manifest. The feature sidecar is per model and stays
exactly as it was.

With one archive, resolve_tiles_url stops choosing between a model field
and a layer field, Model.pmtilesUrl and ArtifactTypes.BUILDING_PMTILES
retire, and GetModelArtifact loses both the "pmtiles" kind and the branch
that reused a model's archive for a layer-scoped request. The Interactive
Labeler reads kind=footprint_pmtiles instead.

Existing embedding models keep a stale pmtilesUrl in their stored
metadata. Nothing reads it, and re-tiling old layers is out of scope by
agreement.

The labeler used to refuse to start when a model had no archive. That
guard is gone with the field, so a failed tile load now raises a clear
error instead of warning to the console and leaving an empty map with no
buildings to label.